package code13.list;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import java.util.Stack;
import java.util.Vector;
import java.util.function.Consumer;

import org.junit.Test;

public class Test01 {
	@Test
	public void f1(){
		// 创建集合容器
		ArrayList<String> list = new ArrayList<>();// 最后的 <> 中内容可以省略
	
		// 一般使用接口 接收实现类对象
		List<String> list2 = new ArrayList<>();
		
		// 可以直接输出，查看元素
		System.out.println(list);
	}
	@Test
	public void f2() {
		// 常用方法
		ArrayList<String> list = new ArrayList<>();
		// 向末尾添加一个元素
		list.add("tom");
		list.add("jerry");
		list.add("tom");// 可以重复
		// 在指定索引(即下标, 从0开始)处添加一个元素
		list.add(1, "neo");
		
		list.add("jerry");
		list.add("jerry");
		
		//list.addAll(c);// 全部加入到当前集合的末尾
		//list.addAll(index, c);// 全部插入到当前集合的指定位置
		System.out.println(list);
		System.out.println("------");
		
		// 修改指定位置的元素, 返回原来的元素
		String old = list.set(3, "Jack");
		System.out.println("old-3:"+old);
		System.out.println(list);
		System.out.println("------");
		
		// 根据索引删除对应位置的元素 int index
		String remove = list.remove(0);// 返回被删除的元素
		System.out.println("remove:"+remove);
		// 删除集合中与参数相同的值(只会删除第一个符合要求的)
		boolean remove2 = list.remove("jerry");
		System.out.println("remove2:"+remove2);
		System.out.println(list);
		System.out.println("------");
		
		// 取指定位置的元素
		String str = list.get(1);
		System.out.println("1:"+str);
		System.out.println("------");
		
		// 获取集合中实际存储的元素个数
		System.out.println("size:"+list.size());
		// 判断集合是否为 空集合
		System.out.println("isEmpty:"+list.isEmpty());
		System.out.println("------");
		
		// 查找元素第一次出现的位置, 不存在返回 -1 
		System.out.println("jerry-first:"+list.indexOf("jerry"));
		// 查找元素最后一次出现的位置, 不存在返回 -1 
		System.out.println("jerry-last:"+list.lastIndexOf("jerry"));
		// 是否包含指定元素
		System.out.println("contains:"+list.contains("neo"));
		System.out.println("------");
		
		// 清空集合
		//list.clear();
		System.out.println(list);
		System.out.println("------");
		
		// 把集合转为数组
		// 默认为 Object类型的
		Object[] array = list.toArray();
		// 转成指定类型的数字, 需要传入对应类型的数组，数组不需有元素，但不能为 null
		String[] arr = list.toArray( new String[]{} );
		System.out.println(Arrays.toString(arr));
	}
	@Test
	public void t1() {
		// 1.随机 随机 10~20个 0~9 的整数存入集合
		// 2.删除集合中 值为 4 的元素
		// 3.统计集合中 6 出现的 次数
		Random r = new Random();
		int count = r.nextInt(11) + 10;// 随机个数
		// 创建集合
		List<Integer> list = new ArrayList<>();
		for (int i = 0; i < count; i++) {
			int num = r.nextInt(10);// 随机元素
			list.add(num);
		}
		System.out.println("old:"+list);
		
		Integer four = 4;
//		boolean f = true;
//		while( f ) {
//			f = list.remove(four);
//		}
		// 等同于以下代码
		while( list.remove(four) ) {}
		System.out.println("remove:"+list);
		
		int count6 = 0;// 6 出现的 次数
		for (int i = 0; i < list.size(); i++) {
			if ( list.get(i) == 6) {
				count6++;
			}
		}
		System.out.println("6 出现的 次数:" + count6);
	}
	@Test
	public void f3() {
		// 可以把数组，转换为 List集合, 该List的 size 是不可变的
		List<Integer> list = Arrays.asList(11, 8, 23, 43);
		//list.add(66);// asList返回的实际的集合类型中 未实现add、remove等方法
		
		// 使用 可以变长的集合存储 上述的元素
		List<Integer> list2 = new ArrayList<>(list);
		
		// List 集合的遍历
		// 1.普通for
		for (int i = 0; i < list2.size(); i++) {
			Integer num = list2.get(i);
			System.out.println(num);
		}
		System.out.println("------------");
		// 2.增强for
		for (Integer num : list2) {
			System.out.println(num);
		}
		System.out.println("------------");
		// 3.使用 Iterator 迭代器。
		// 获取迭代器对象
		Iterator<Integer> it = list2.iterator();
		// hasNext 判断是否有下一个元素
		while(it.hasNext()){
			// 有, 使用 next() 取这个元素
			Integer next = it.next();
			System.out.println(next);
			// 可以使用 删除当前的这个元素
			//it.remove();
			// 使用迭代器的时候，不能同时使用 集合的 add / reomve 方法
			//list2.add(11);
			//list2.remove(11);
		}
		System.out.println("------------");
		// 4.jdk8
		list2.forEach(new Consumer<Integer>() {
			@Override
			public void accept(Integer t) {
				System.out.println(t);// 当前遍历的元素
			}
		});
		System.out.println("------------");
		// 了解
		list2.forEach(System.out::println);
	}
	
	@Test
	public void f4() {
		Vector<Integer> v = new Vector<>(Arrays.asList(11,22,33,44,55));
		// 使用 Enumeration 遍历, 用法和 迭代器相同
		Enumeration<Integer> e = v.elements();
		// 判断是否存在下一个元素
		while(e.hasMoreElements()) {
			// 有, 取出
			Integer element = e.nextElement();
			System.out.println(element);
		}
		// 获取线程安全的 List 集合
		List<Object> synchronizedList = Collections.synchronizedList(new ArrayList<>());
	}
	@Test
	public void f5() {
		Stack<String> stack = new Stack<>();
		// 入栈
		stack.push("0");
		stack.push("1");
		stack.push("2");
		stack.push("3");
		System.out.println(stack);
		
		// 出栈
		String pop1 = stack.pop();
		System.out.println("pop1:"+pop1);//3
		
		String pop2 = stack.pop();
		System.out.println("pop2:"+pop2);//2
		
		String pop3 = stack.pop();
		System.out.println("pop3:"+pop3);//1
		
		// 查询栈顶部的元素
		String peek = stack.peek();
		System.out.println(peek);
		
		System.out.println(stack);
		
	}
	
	@Test
	public void f6() {
		LinkedList<String> list = new LinkedList<String>();
		
		// addFirst 在头部添加
		list.addFirst("11");
		list.addLast("999");
		System.out.println("list:" + list);
		list.addFirst("22");
		list.addLast("88");
		System.out.println("list:" + list);
		System.out.println("----");
		
		// 查看 第一个/ 最后一个 元素
		String first = list.getFirst();
		String last = list.getLast();
		System.out.println("first:"+first);
		System.out.println("last:"+last);
		System.out.println("----");
		
		// 删除并返回第一个元素
		String removeFirst = list.removeFirst();
		System.out.println("removeFirst:"+removeFirst);
		// 删除并返回最一个元素
		String removeLast = list.removeLast();
		System.out.println("removeLast:"+removeLast);
	}
}
